id_within_dataset int64 1 55.5k | snippet stringlengths 19 14.2k | tokens listlengths 6 1.63k | nl stringlengths 6 352 | split_within_dataset stringclasses 1 value | is_duplicated bool 2 classes |
|---|---|---|---|---|---|
1 | def install_translator(qapp):
global QT_TRANSLATOR
if (QT_TRANSLATOR is None):
qt_translator = QTranslator()
if qt_translator.load(('qt_' + QLocale.system().name()), QLibraryInfo.location(QLibraryInfo.TranslationsPath)):
QT_TRANSLATOR = qt_translator
if (QT_TRANSLATOR is not None):
qapp.installTranslator(QT_TRANSLATOR)
| [
"def",
"install_translator",
"(",
"qapp",
")",
":",
"global",
"QT_TRANSLATOR",
"if",
"(",
"QT_TRANSLATOR",
"is",
"None",
")",
":",
"qt_translator",
"=",
"QTranslator",
"(",
")",
"if",
"qt_translator",
".",
"load",
"(",
"(",
"'qt_'",
"+",
"QLocale",
".",
"s... | install qt translator to the qapplication instance . | train | true |
2 | def delete_dhcp_options(dhcp_options_id=None, dhcp_options_name=None, region=None, key=None, keyid=None, profile=None):
return _delete_resource(resource='dhcp_options', name=dhcp_options_name, resource_id=dhcp_options_id, region=region, key=key, keyid=keyid, profile=profile)
| [
"def",
"delete_dhcp_options",
"(",
"dhcp_options_id",
"=",
"None",
",",
"dhcp_options_name",
"=",
"None",
",",
"region",
"=",
"None",
",",
"key",
"=",
"None",
",",
"keyid",
"=",
"None",
",",
"profile",
"=",
"None",
")",
":",
"return",
"_delete_resource",
"... | delete dhcp options by id or name . | train | true |
4 | def test_depth_first_mro():
class A(object, ):
pass
class B(A, ):
pass
class C(A, ):
pass
class D(B, C, ):
pass
class E(D, object, ):
pass
class G(object, ):
pass
class H(G, ):
pass
class I(G, ):
pass
class K(H, I, object, ):
pass
class L(K, E, ):
pass
AreEqual(L.__mro__, (L, K, H, I, G, E, D, B, C, A, object))
| [
"def",
"test_depth_first_mro",
"(",
")",
":",
"class",
"A",
"(",
"object",
",",
")",
":",
"pass",
"class",
"B",
"(",
"A",
",",
")",
":",
"pass",
"class",
"C",
"(",
"A",
",",
")",
":",
"pass",
"class",
"D",
"(",
"B",
",",
"C",
",",
")",
":",
... | w/o old-style . | train | false |
5 | def mapping(data_source, geom_name='geom', layer_key=0, multi_geom=False):
if isinstance(data_source, six.string_types):
data_source = DataSource(data_source)
elif isinstance(data_source, DataSource):
pass
else:
raise TypeError('Data source parameter must be a string or a DataSource object.')
_mapping = {}
for field in data_source[layer_key].fields:
mfield = field.lower()
if (mfield[(-1):] == '_'):
mfield += 'field'
_mapping[mfield] = field
gtype = data_source[layer_key].geom_type
if (multi_geom and (gtype.num in (1, 2, 3))):
prefix = 'MULTI'
else:
prefix = ''
_mapping[geom_name] = (prefix + str(gtype).upper())
return _mapping
| [
"def",
"mapping",
"(",
"data_source",
",",
"geom_name",
"=",
"'geom'",
",",
"layer_key",
"=",
"0",
",",
"multi_geom",
"=",
"False",
")",
":",
"if",
"isinstance",
"(",
"data_source",
",",
"six",
".",
"string_types",
")",
":",
"data_source",
"=",
"DataSource... | given a datasource . | train | false |
7 | def test_pprint_npfloat32():
dat = np.array([1.0, 2.0], dtype=np.float32)
t = Table([dat], names=['a'])
t['a'].format = '5.2f'
assert (str(t['a']) == ' a \n-----\n 1.00\n 2.00')
| [
"def",
"test_pprint_npfloat32",
"(",
")",
":",
"dat",
"=",
"np",
".",
"array",
"(",
"[",
"1.0",
",",
"2.0",
"]",
",",
"dtype",
"=",
"np",
".",
"float32",
")",
"t",
"=",
"Table",
"(",
"[",
"dat",
"]",
",",
"names",
"=",
"[",
"'a'",
"]",
")",
"... | test for #148 . | train | false |
8 | def test_interpolation():
(t0, k0) = (0, np.array([5.0]))
results = _compute_fixed_length_solns(model, t0, k0)
for (integrator, numeric_solution) in results.items():
(N, T) = (1000, numeric_solution[:, 0][(-1)])
ti = np.linspace(t0, T, N)
interp_solution = model.interpolate(numeric_solution, ti, k=3, ext=2)
analytic_solution = solow_analytic_solution(ti, k0, *valid_params)
np.testing.assert_allclose(interp_solution, analytic_solution)
| [
"def",
"test_interpolation",
"(",
")",
":",
"(",
"t0",
",",
"k0",
")",
"=",
"(",
"0",
",",
"np",
".",
"array",
"(",
"[",
"5.0",
"]",
")",
")",
"results",
"=",
"_compute_fixed_length_solns",
"(",
"model",
",",
"t0",
",",
"k0",
")",
"for",
"(",
"in... | test interpolation option . | train | false |
9 | def _save_and_remove_module(name, orig_modules):
if (name not in sys.modules):
__import__(name)
del sys.modules[name]
for modname in list(sys.modules):
if ((modname == name) or modname.startswith((name + '.'))):
orig_modules[modname] = sys.modules[modname]
del sys.modules[modname]
| [
"def",
"_save_and_remove_module",
"(",
"name",
",",
"orig_modules",
")",
":",
"if",
"(",
"name",
"not",
"in",
"sys",
".",
"modules",
")",
":",
"__import__",
"(",
"name",
")",
"del",
"sys",
".",
"modules",
"[",
"name",
"]",
"for",
"modname",
"in",
"list... | helper function to save and remove a module from sys . | train | false |
12 | def url2ip(url):
iport = urlsplit(url)[1].split(':')
if (len(iport) > 1):
return (gethostbyname(iport[0]), iport[1])
return gethostbyname(iport[0])
| [
"def",
"url2ip",
"(",
"url",
")",
":",
"iport",
"=",
"urlsplit",
"(",
"url",
")",
"[",
"1",
"]",
".",
"split",
"(",
"':'",
")",
"if",
"(",
"len",
"(",
"iport",
")",
">",
"1",
")",
":",
"return",
"(",
"gethostbyname",
"(",
"iport",
"[",
"0",
"... | works like turning URL => 180 . | train | false |
13 | def _wait_until_running(instance):
with start_action(action_type=u'flocker:provision:aws:wait_until_running', instance_id=instance.id) as context:
_poll_while((lambda : _node_is_booting(instance)), repeat(1, INSTANCE_TIMEOUT))
context.add_success_fields(instance_state=instance.state)
context.add_success_fields(instance_state_reason=instance.state_reason)
if (instance.state != u'running'):
raise FailedToRun(instance.state_reason)
| [
"def",
"_wait_until_running",
"(",
"instance",
")",
":",
"with",
"start_action",
"(",
"action_type",
"=",
"u'flocker:provision:aws:wait_until_running'",
",",
"instance_id",
"=",
"instance",
".",
"id",
")",
"as",
"context",
":",
"_poll_while",
"(",
"(",
"lambda",
"... | wait until a instance is running . | train | false |
14 | def dict_to_numpy_array(d, mapping=None):
try:
return dict_to_numpy_array2(d, mapping)
except (AttributeError, TypeError):
return dict_to_numpy_array1(d, mapping)
| [
"def",
"dict_to_numpy_array",
"(",
"d",
",",
"mapping",
"=",
"None",
")",
":",
"try",
":",
"return",
"dict_to_numpy_array2",
"(",
"d",
",",
"mapping",
")",
"except",
"(",
"AttributeError",
",",
"TypeError",
")",
":",
"return",
"dict_to_numpy_array1",
"(",
"d... | convert a dictionary of dictionaries to a numpy array with optional mapping . | train | false |
15 | def _is_suggestion_handled(thread_id, exploration_id):
thread = feedback_models.FeedbackThreadModel.get_by_exp_and_thread_id(exploration_id, thread_id)
return (thread.status in [feedback_models.STATUS_CHOICES_FIXED, feedback_models.STATUS_CHOICES_IGNORED])
| [
"def",
"_is_suggestion_handled",
"(",
"thread_id",
",",
"exploration_id",
")",
":",
"thread",
"=",
"feedback_models",
".",
"FeedbackThreadModel",
".",
"get_by_exp_and_thread_id",
"(",
"exploration_id",
",",
"thread_id",
")",
"return",
"(",
"thread",
".",
"status",
"... | checks if the current suggestion has already been accepted/rejected . | train | false |
17 | def get_default_site(app_name='filebrowser'):
resolver = get_resolver(get_urlconf())
name = 'filebrowser'
app_list = resolver.app_dict[app_name]
if (name not in app_list):
name = app_list[0]
return get_site_dict()[name]
| [
"def",
"get_default_site",
"(",
"app_name",
"=",
"'filebrowser'",
")",
":",
"resolver",
"=",
"get_resolver",
"(",
"get_urlconf",
"(",
")",
")",
"name",
"=",
"'filebrowser'",
"app_list",
"=",
"resolver",
".",
"app_dict",
"[",
"app_name",
"]",
"if",
"(",
"name... | returns the default site . | train | false |
18 | def ccovf(x, y, unbiased=True, demean=True):
n = len(x)
if demean:
xo = (x - x.mean())
yo = (y - y.mean())
else:
xo = x
yo = y
if unbiased:
xi = np.ones(n)
d = np.correlate(xi, xi, 'full')
else:
d = n
return (np.correlate(xo, yo, 'full') / d)[(n - 1):]
| [
"def",
"ccovf",
"(",
"x",
",",
"y",
",",
"unbiased",
"=",
"True",
",",
"demean",
"=",
"True",
")",
":",
"n",
"=",
"len",
"(",
"x",
")",
"if",
"demean",
":",
"xo",
"=",
"(",
"x",
"-",
"x",
".",
"mean",
"(",
")",
")",
"yo",
"=",
"(",
"y",
... | crosscovariance for 1d parameters x . | train | false |
20 | def serializers(**serializers):
def decorator(func):
if (not hasattr(func, 'wsgi_serializers')):
func.wsgi_serializers = {}
func.wsgi_serializers.update(serializers)
return func
return decorator
| [
"def",
"serializers",
"(",
"**",
"serializers",
")",
":",
"def",
"decorator",
"(",
"func",
")",
":",
"if",
"(",
"not",
"hasattr",
"(",
"func",
",",
"'wsgi_serializers'",
")",
")",
":",
"func",
".",
"wsgi_serializers",
"=",
"{",
"}",
"func",
".",
"wsgi_... | returns the serializers modules . | train | false |
21 | def rgb2short(r, g, b):
incs = (0, 95, 135, 175, 215, 255)
parts = [r, g, b]
res = []
for part in parts:
i = 0
while (i < (len(incs) - 1)):
(s, b) = (incs[i], incs[(i + 1)])
if (s <= part <= b):
s1 = abs((s - part))
b1 = abs((b - part))
if (s1 < b1):
closest = s
else:
closest = b
res.append(closest)
break
i += 1
return RGB2SHORT_DICT[tuple(res)]
| [
"def",
"rgb2short",
"(",
"r",
",",
"g",
",",
"b",
")",
":",
"incs",
"=",
"(",
"0",
",",
"95",
",",
"135",
",",
"175",
",",
"215",
",",
"255",
")",
"parts",
"=",
"[",
"r",
",",
"g",
",",
"b",
"]",
"res",
"=",
"[",
"]",
"for",
"part",
"in... | rgb to short . | train | true |
22 | def output():
return s3_rest_controller()
| [
"def",
"output",
"(",
")",
":",
"return",
"s3_rest_controller",
"(",
")"
] | output -> html string either return the result of a function or a sparse htmlized error message and a message in the server log . | train | false |
24 | def gf_factor_sqf(f, p, K, method=None):
(lc, f) = gf_monic(f, p, K)
if (gf_degree(f) < 1):
return (lc, [])
method = (method or query('GF_FACTOR_METHOD'))
if (method is not None):
factors = _factor_methods[method](f, p, K)
else:
factors = gf_zassenhaus(f, p, K)
return (lc, factors)
| [
"def",
"gf_factor_sqf",
"(",
"f",
",",
"p",
",",
"K",
",",
"method",
"=",
"None",
")",
":",
"(",
"lc",
",",
"f",
")",
"=",
"gf_monic",
"(",
"f",
",",
"p",
",",
"K",
")",
"if",
"(",
"gf_degree",
"(",
"f",
")",
"<",
"1",
")",
":",
"return",
... | factor a square-free polynomial f in gf(p)[x] . | train | false |
26 | def draw_nx(G, pos, **kwds):
draw(G, pos, **kwds)
| [
"def",
"draw_nx",
"(",
"G",
",",
"pos",
",",
"**",
"kwds",
")",
":",
"draw",
"(",
"G",
",",
"pos",
",",
"**",
"kwds",
")"
] | for backward compatibility; use draw or draw_networkx . | train | false |
27 | def start_clientbrowser(config, args):
logger.info('Start client mode (browser)')
global client
from glances.client_browser import GlancesClientBrowser
client = GlancesClientBrowser(config=config, args=args)
client.serve_forever()
client.end()
| [
"def",
"start_clientbrowser",
"(",
"config",
",",
"args",
")",
":",
"logger",
".",
"info",
"(",
"'Start client mode (browser)'",
")",
"global",
"client",
"from",
"glances",
".",
"client_browser",
"import",
"GlancesClientBrowser",
"client",
"=",
"GlancesClientBrowser",... | start the browser client mode . | train | false |
28 | @raises(ValueError)
def test_bootstrap_arglength():
algo.bootstrap(np.arange(5), np.arange(10))
| [
"@",
"raises",
"(",
"ValueError",
")",
"def",
"test_bootstrap_arglength",
"(",
")",
":",
"algo",
".",
"bootstrap",
"(",
"np",
".",
"arange",
"(",
"5",
")",
",",
"np",
".",
"arange",
"(",
"10",
")",
")"
] | test that different length args raise valueerror . | train | false |
29 | def runwsgi(func):
if os.environ.has_key('SERVER_SOFTWARE'):
os.environ['FCGI_FORCE_CGI'] = 'Y'
if (os.environ.has_key('PHP_FCGI_CHILDREN') or os.environ.has_key('SERVER_SOFTWARE')):
import flup.server.fcgi
return runfcgi(func)
if ('scgi' in sys.argv):
import flup.server.scgi
return runscgi(func)
return runsimple(func, listget(sys.argv, 1, 8080))
| [
"def",
"runwsgi",
"(",
"func",
")",
":",
"if",
"os",
".",
"environ",
".",
"has_key",
"(",
"'SERVER_SOFTWARE'",
")",
":",
"os",
".",
"environ",
"[",
"'FCGI_FORCE_CGI'",
"]",
"=",
"'Y'",
"if",
"(",
"os",
".",
"environ",
".",
"has_key",
"(",
"'PHP_FCGI_CH... | runs a wsgi-compatible function using fcgi . | train | false |
30 | def random_bucket_name(prefix='awscli-s3integ-', num_random=10):
return (prefix + random_chars(num_random))
| [
"def",
"random_bucket_name",
"(",
"prefix",
"=",
"'awscli-s3integ-'",
",",
"num_random",
"=",
"10",
")",
":",
"return",
"(",
"prefix",
"+",
"random_chars",
"(",
"num_random",
")",
")"
] | generate a random s3 bucket name . | train | false |
31 | def _proxy_process(proxyname, test):
changes_old = []
changes_new = []
if (not _is_proxy_running(proxyname)):
if (not test):
__salt__['cmd.run_all']('salt-proxy --proxyid={0} -l info -d'.format(salt.ext.six.moves.shlex_quote(proxyname)), timeout=5)
changes_new.append('Salt Proxy: Started proxy process for {0}'.format(proxyname))
else:
changes_new.append('Salt Proxy: process {0} will be started'.format(proxyname))
else:
changes_old.append('Salt Proxy: already running for {0}'.format(proxyname))
return (True, changes_new, changes_old)
| [
"def",
"_proxy_process",
"(",
"proxyname",
",",
"test",
")",
":",
"changes_old",
"=",
"[",
"]",
"changes_new",
"=",
"[",
"]",
"if",
"(",
"not",
"_is_proxy_running",
"(",
"proxyname",
")",
")",
":",
"if",
"(",
"not",
"test",
")",
":",
"__salt__",
"[",
... | check and execute proxy process . | train | true |
32 | def _offset_or_limit_clause(element, name=None, type_=None):
if (element is None):
return None
elif hasattr(element, '__clause_element__'):
return element.__clause_element__()
elif isinstance(element, Visitable):
return element
else:
value = util.asint(element)
return _OffsetLimitParam(name, value, type_=type_, unique=True)
| [
"def",
"_offset_or_limit_clause",
"(",
"element",
",",
"name",
"=",
"None",
",",
"type_",
"=",
"None",
")",
":",
"if",
"(",
"element",
"is",
"None",
")",
":",
"return",
"None",
"elif",
"hasattr",
"(",
"element",
",",
"'__clause_element__'",
")",
":",
"re... | convert the given value to an "offset or limit" clause . | train | false |
34 | def _retrieve_device_config():
return __salt__['snmp.config']()
| [
"def",
"_retrieve_device_config",
"(",
")",
":",
"return",
"__salt__",
"[",
"'snmp.config'",
"]",
"(",
")"
] | retrieves the snmp config from the device . | train | false |
35 | def normalize_formset_dict(formset, attr_list):
assert isinstance(formset, BaseSimpleFormSet)
res = []
for form in formset.forms:
res.append(normalize_form_dict(form, attr_list))
return res
| [
"def",
"normalize_formset_dict",
"(",
"formset",
",",
"attr_list",
")",
":",
"assert",
"isinstance",
"(",
"formset",
",",
"BaseSimpleFormSet",
")",
"res",
"=",
"[",
"]",
"for",
"form",
"in",
"formset",
".",
"forms",
":",
"res",
".",
"append",
"(",
"normali... | normalize_formset_dict -> a list of dictionary of . | train | false |
36 | def parse_strtime(timestr, fmt=PERFECT_TIME_FORMAT):
return datetime.datetime.strptime(timestr, fmt)
| [
"def",
"parse_strtime",
"(",
"timestr",
",",
"fmt",
"=",
"PERFECT_TIME_FORMAT",
")",
":",
"return",
"datetime",
".",
"datetime",
".",
"strptime",
"(",
"timestr",
",",
"fmt",
")"
] | turn a formatted time back into a datetime . | train | false |
37 | def hash_filehash(filename):
md4 = hashlib.new(u'md4').copy
def gen(f):
while True:
x = f.read(9728000)
if x:
(yield x)
else:
return
def md4_hash(data):
m = md4()
m.update(data)
return m
with open(filename, u'rb') as f:
a = gen(f)
hashes = [md4_hash(data).digest() for data in a]
if (len(hashes) == 1):
return to_hex(hashes[0])
else:
return md4_hash(reduce((lambda a, d: (a + d)), hashes, u'')).hexd
| [
"def",
"hash_filehash",
"(",
"filename",
")",
":",
"md4",
"=",
"hashlib",
".",
"new",
"(",
"u'md4'",
")",
".",
"copy",
"def",
"gen",
"(",
"f",
")",
":",
"while",
"True",
":",
"x",
"=",
"f",
".",
"read",
"(",
"9728000",
")",
"if",
"x",
":",
"(",... | returns the ed2k hash of a given file . | train | false |
39 | @receiver(user_logged_in)
def log_successful_login(sender, request, user, **kwargs):
if settings.FEATURES['SQUELCH_PII_IN_LOGS']:
AUDIT_LOG.info(u'Login success - user.id: {0}'.format(user.id))
else:
AUDIT_LOG.info(u'Login success - {0} ({1})'.format(user.username, user.email))
| [
"@",
"receiver",
"(",
"user_logged_in",
")",
"def",
"log_successful_login",
"(",
"sender",
",",
"request",
",",
"user",
",",
"**",
"kwargs",
")",
":",
"if",
"settings",
".",
"FEATURES",
"[",
"'SQUELCH_PII_IN_LOGS'",
"]",
":",
"AUDIT_LOG",
".",
"info",
"(",
... | handler to log when logins have occurred successfully . | train | false |
43 | def zoom_effect02(ax1, ax2, **kwargs):
tt = (ax1.transScale + (ax1.transLimits + ax2.transAxes))
trans = blended_transform_factory(ax2.transData, tt)
mybbox1 = ax1.bbox
mybbox2 = TransformedBbox(ax1.viewLim, trans)
prop_patches = kwargs.copy()
prop_patches['ec'] = 'none'
prop_patches['alpha'] = 0.2
(c1, c2, bbox_patch1, bbox_patch2, p) = connect_bbox(mybbox1, mybbox2, loc1a=3, loc2a=2, loc1b=4, loc2b=1, prop_lines=kwargs, prop_patches=prop_patches)
ax1.add_patch(bbox_patch1)
ax2.add_patch(bbox_patch2)
ax2.add_patch(c1)
ax2.add_patch(c2)
ax2.add_patch(p)
return (c1, c2, bbox_patch1, bbox_patch2, p)
| [
"def",
"zoom_effect02",
"(",
"ax1",
",",
"ax2",
",",
"**",
"kwargs",
")",
":",
"tt",
"=",
"(",
"ax1",
".",
"transScale",
"+",
"(",
"ax1",
".",
"transLimits",
"+",
"ax2",
".",
"transAxes",
")",
")",
"trans",
"=",
"blended_transform_factory",
"(",
"ax2",... | ax1 : the main axes ax1 : the zoomed axes similar to zoom_effect01 . | train | false |
44 | def _expand_table(table):
return np.repeat([[1, 1], [1, 0], [0, 1], [0, 0]], table.ravel(), axis=0)
| [
"def",
"_expand_table",
"(",
"table",
")",
":",
"return",
"np",
".",
"repeat",
"(",
"[",
"[",
"1",
",",
"1",
"]",
",",
"[",
"1",
",",
"0",
"]",
",",
"[",
"0",
",",
"1",
"]",
",",
"[",
"0",
",",
"0",
"]",
"]",
",",
"table",
".",
"ravel",
... | expand a 2 by 2 contingency table to observations . | train | false |
45 | def load_extra_data(backend, details, response, uid, user, social_user=None, *args, **kwargs):
social_user = (social_user or UserSocialAuth.get_social_auth(backend.name, uid, user))
if social_user:
extra_data = backend.extra_data(user, uid, response, details)
if (kwargs.get('original_email') and ('email' not in extra_data)):
extra_data['email'] = kwargs.get('original_email')
if (extra_data and (social_user.extra_data != extra_data)):
if social_user.extra_data:
social_user.extra_data.update(extra_data)
else:
social_user.extra_data = extra_data
social_user.save()
return {'social_user': social_user}
| [
"def",
"load_extra_data",
"(",
"backend",
",",
"details",
",",
"response",
",",
"uid",
",",
"user",
",",
"social_user",
"=",
"None",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"social_user",
"=",
"(",
"social_user",
"or",
"UserSocialAuth",
".",
"ge... | load extra data from provider and store it on current usersocialauth extra_data field . | train | false |
46 | def arbitrary(module_name, func_name, args, kwargs={}):
if module_name.startswith('calibre_plugins'):
from calibre.customize.ui import find_plugin
find_plugin
module = importlib.import_module(module_name)
func = getattr(module, func_name)
return func(*args, **kwargs)
| [
"def",
"arbitrary",
"(",
"module_name",
",",
"func_name",
",",
"args",
",",
"kwargs",
"=",
"{",
"}",
")",
":",
"if",
"module_name",
".",
"startswith",
"(",
"'calibre_plugins'",
")",
":",
"from",
"calibre",
".",
"customize",
".",
"ui",
"import",
"find_plugi... | an entry point that allows arbitrary functions to be run in a parallel process . | train | false |
47 | def claModelControlDisableTPLearningCb(claModel):
assert isinstance(claModel, CLAModel)
claModel._getTPRegion().setParameter('learningMode', False)
return
| [
"def",
"claModelControlDisableTPLearningCb",
"(",
"claModel",
")",
":",
"assert",
"isinstance",
"(",
"claModel",
",",
"CLAModel",
")",
"claModel",
".",
"_getTPRegion",
"(",
")",
".",
"setParameter",
"(",
"'learningMode'",
",",
"False",
")",
"return"
] | disables learning in the cla models temporal pooler . | train | false |
48 | def create_api_deployment(restApiId, stageName, stageDescription='', description='', cacheClusterEnabled=False, cacheClusterSize='0.5', variables=None, region=None, key=None, keyid=None, profile=None):
try:
variables = (dict() if (variables is None) else variables)
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
deployment = conn.create_deployment(restApiId=restApiId, stageName=stageName, stageDescription=stageDescription, description=description, cacheClusterEnabled=cacheClusterEnabled, cacheClusterSize=cacheClusterSize, variables=variables)
return {'created': True, 'deployment': _convert_datetime_str(deployment)}
except ClientError as e:
return {'created': False, 'error': salt.utils.boto3.get_error(e)}
| [
"def",
"create_api_deployment",
"(",
"restApiId",
",",
"stageName",
",",
"stageDescription",
"=",
"''",
",",
"description",
"=",
"''",
",",
"cacheClusterEnabled",
"=",
"False",
",",
"cacheClusterSize",
"=",
"'0.5'",
",",
"variables",
"=",
"None",
",",
"region",
... | creates a new api deployment . | train | true |
49 | def _point_along_a_line(x0, y0, x1, y1, d):
(dx, dy) = ((x0 - x1), (y0 - y1))
ff = (d / (((dx * dx) + (dy * dy)) ** 0.5))
(x2, y2) = ((x0 - (ff * dx)), (y0 - (ff * dy)))
return (x2, y2)
| [
"def",
"_point_along_a_line",
"(",
"x0",
",",
"y0",
",",
"x1",
",",
"y1",
",",
"d",
")",
":",
"(",
"dx",
",",
"dy",
")",
"=",
"(",
"(",
"x0",
"-",
"x1",
")",
",",
"(",
"y0",
"-",
"y1",
")",
")",
"ff",
"=",
"(",
"d",
"/",
"(",
"(",
"(",
... | find a point along a line connecting -- whose distance from is d . | train | false |
50 | def s3_roles_permitted(name='roles_permitted', **attr):
T = current.T
represent = S3Represent(lookup='auth_group', fields=['role'])
if ('label' not in attr):
attr['label'] = T('Roles Permitted')
if ('sortby' not in attr):
attr['sortby'] = 'role'
if ('represent' not in attr):
attr['represent'] = represent
if ('requires' not in attr):
attr['requires'] = IS_EMPTY_OR(IS_ONE_OF(current.db, 'auth_group.id', represent, multiple=True))
if ('comment' not in attr):
attr['comment'] = DIV(_class='tooltip', _title=('%s|%s' % (T('Roles Permitted'), T('If this record should be restricted then select which role(s) are permitted to access the record here.'))))
if ('ondelete' not in attr):
attr['ondelete'] = 'RESTRICT'
f = S3ReusableField(name, 'list:reference auth_group', **attr)
return f()
| [
"def",
"s3_roles_permitted",
"(",
"name",
"=",
"'roles_permitted'",
",",
"**",
"attr",
")",
":",
"T",
"=",
"current",
".",
"T",
"represent",
"=",
"S3Represent",
"(",
"lookup",
"=",
"'auth_group'",
",",
"fields",
"=",
"[",
"'role'",
"]",
")",
"if",
"(",
... | list of roles permitted to access a resource - used by cms . | train | false |
52 | @pick_context_manager_writer
def instance_group_update(context, group_uuid, values):
group = model_query(context, models.InstanceGroup).filter_by(uuid=group_uuid).first()
if (not group):
raise exception.InstanceGroupNotFound(group_uuid=group_uuid)
policies = values.get('policies')
if (policies is not None):
_instance_group_policies_add(context, group.id, values.pop('policies'), set_delete=True)
members = values.get('members')
if (members is not None):
_instance_group_members_add(context, group.id, values.pop('members'), set_delete=True)
group.update(values)
if policies:
values['policies'] = policies
if members:
values['members'] = members
| [
"@",
"pick_context_manager_writer",
"def",
"instance_group_update",
"(",
"context",
",",
"group_uuid",
",",
"values",
")",
":",
"group",
"=",
"model_query",
"(",
"context",
",",
"models",
".",
"InstanceGroup",
")",
".",
"filter_by",
"(",
"uuid",
"=",
"group_uuid... | update the attributes of an group . | train | false |
53 | def _tree_to_bitstrs(tree):
clades_bitstrs = {}
term_names = [term.name for term in tree.find_clades(terminal=True)]
for clade in tree.find_clades(terminal=False):
bitstr = _clade_to_bitstr(clade, term_names)
clades_bitstrs[clade] = bitstr
return clades_bitstrs
| [
"def",
"_tree_to_bitstrs",
"(",
"tree",
")",
":",
"clades_bitstrs",
"=",
"{",
"}",
"term_names",
"=",
"[",
"term",
".",
"name",
"for",
"term",
"in",
"tree",
".",
"find_clades",
"(",
"terminal",
"=",
"True",
")",
"]",
"for",
"clade",
"in",
"tree",
".",
... | create a dict of a trees clades to corresponding bitstrings . | train | false |
54 | def timeuntil(d, now=None):
return timesince(d, now, reversed=True)
| [
"def",
"timeuntil",
"(",
"d",
",",
"now",
"=",
"None",
")",
":",
"return",
"timesince",
"(",
"d",
",",
"now",
",",
"reversed",
"=",
"True",
")"
] | formats a date as the time until that date . | train | false |
56 | def test_hashbang():
entry = tokenize('#!this is a comment\n')
assert (entry == [])
| [
"def",
"test_hashbang",
"(",
")",
":",
"entry",
"=",
"tokenize",
"(",
"'#!this is a comment\\n'",
")",
"assert",
"(",
"entry",
"==",
"[",
"]",
")"
] | ensure we can escape things . | train | false |
59 | @context.quietfunc
@with_device
def exists(path):
with AdbClient() as c:
return bool(c.stat(path))
| [
"@",
"context",
".",
"quietfunc",
"@",
"with_device",
"def",
"exists",
"(",
"path",
")",
":",
"with",
"AdbClient",
"(",
")",
"as",
"c",
":",
"return",
"bool",
"(",
"c",
".",
"stat",
"(",
"path",
")",
")"
] | check if a user exists . | train | false |
60 | def disassociate_api_key_stagekeys(apiKey, stagekeyslist, region=None, key=None, keyid=None, profile=None):
try:
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
pvlist = [('/stages', stagekey) for stagekey in stagekeyslist]
response = _api_key_patch_remove(conn, apiKey, pvlist)
return {'disassociated': True}
except ClientError as e:
return {'disassociated': False, 'error': salt.utils.boto3.get_error(e)}
| [
"def",
"disassociate_api_key_stagekeys",
"(",
"apiKey",
",",
"stagekeyslist",
",",
"region",
"=",
"None",
",",
"key",
"=",
"None",
",",
"keyid",
"=",
"None",
",",
"profile",
"=",
"None",
")",
":",
"try",
":",
"conn",
"=",
"_get_conn",
"(",
"region",
"=",... | disassociate the given stagekeyslist to the given apikey . | train | false |
61 | @then(u'we see database dropped')
def step_see_db_dropped(context):
_expect_exact(context, u'DROP DATABASE', timeout=2)
| [
"@",
"then",
"(",
"u'we see database dropped'",
")",
"def",
"step_see_db_dropped",
"(",
"context",
")",
":",
"_expect_exact",
"(",
"context",
",",
"u'DROP DATABASE'",
",",
"timeout",
"=",
"2",
")"
] | wait to see drop database output . | train | false |
62 | @bdd.when(bdd.parsers.parse('I wait for the javascript message "{message}"'))
def javascript_message_when(quteproc, message):
quteproc.wait_for_js(message)
| [
"@",
"bdd",
".",
"when",
"(",
"bdd",
".",
"parsers",
".",
"parse",
"(",
"'I wait for the javascript message \"{message}\"'",
")",
")",
"def",
"javascript_message_when",
"(",
"quteproc",
",",
"message",
")",
":",
"quteproc",
".",
"wait_for_js",
"(",
"message",
")... | make sure the given message was logged via javascript . | train | false |
63 | def _gitPresent():
try:
gitvers = subprocess.check_output('git --version'.split(), stderr=subprocess.PIPE)
except (CalledProcessError, OSError):
gitvers = ''
return bool(gitvers.startswith('git version'))
| [
"def",
"_gitPresent",
"(",
")",
":",
"try",
":",
"gitvers",
"=",
"subprocess",
".",
"check_output",
"(",
"'git --version'",
".",
"split",
"(",
")",
",",
"stderr",
"=",
"subprocess",
".",
"PIPE",
")",
"except",
"(",
"CalledProcessError",
",",
"OSError",
")"... | check for git on command-line . | train | false |
64 | def create_mount_target(filesystemid, subnetid, ipaddress=None, securitygroups=None, keyid=None, key=None, profile=None, region=None, **kwargs):
client = _get_conn(key=key, keyid=keyid, profile=profile, region=region)
return client.create_mount_point(FileSystemId=filesystemid, SubnetId=subnetid, IpAddress=ipaddress, SecurityGroups=securitygroups)
| [
"def",
"create_mount_target",
"(",
"filesystemid",
",",
"subnetid",
",",
"ipaddress",
"=",
"None",
",",
"securitygroups",
"=",
"None",
",",
"keyid",
"=",
"None",
",",
"key",
"=",
"None",
",",
"profile",
"=",
"None",
",",
"region",
"=",
"None",
",",
"**",... | creates a mount target for a file system . | train | false |
65 | def IsAutoGenerated(xml_str):
try:
xml_root = ElementTree.fromstring(xml_str)
return ((xml_root.tag == 'datastore-indexes') and _BooleanAttribute(xml_root.attrib.get('autoGenerate', 'false')))
except ElementTree.ParseError:
return False
| [
"def",
"IsAutoGenerated",
"(",
"xml_str",
")",
":",
"try",
":",
"xml_root",
"=",
"ElementTree",
".",
"fromstring",
"(",
"xml_str",
")",
"return",
"(",
"(",
"xml_root",
".",
"tag",
"==",
"'datastore-indexes'",
")",
"and",
"_BooleanAttribute",
"(",
"xml_root",
... | test if the given datastore-indexes . | train | false |
66 | def jnp_zeros(n, nt):
return jnyn_zeros(n, nt)[1]
| [
"def",
"jnp_zeros",
"(",
"n",
",",
"nt",
")",
":",
"return",
"jnyn_zeros",
"(",
"n",
",",
"nt",
")",
"[",
"1",
"]"
] | compute zeros of integer-order bessel function derivative jn(x) . | train | false |
68 | def set_time(time):
time_format = _get_date_time_format(time)
dt_obj = datetime.strptime(time, time_format)
cmd = 'systemsetup -settime {0}'.format(dt_obj.strftime('%H:%M:%S'))
return salt.utils.mac_utils.execute_return_success(cmd)
| [
"def",
"set_time",
"(",
"time",
")",
":",
"time_format",
"=",
"_get_date_time_format",
"(",
"time",
")",
"dt_obj",
"=",
"datetime",
".",
"strptime",
"(",
"time",
",",
"time_format",
")",
"cmd",
"=",
"'systemsetup -settime {0}'",
".",
"format",
"(",
"dt_obj",
... | sets the current time . | train | true |
69 | def del_job_files(job_paths):
for path in job_paths:
if (path and clip_path(path).lower().startswith(cfg.download_dir.get_path().lower())):
remove_all(path, recursive=True)
| [
"def",
"del_job_files",
"(",
"job_paths",
")",
":",
"for",
"path",
"in",
"job_paths",
":",
"if",
"(",
"path",
"and",
"clip_path",
"(",
"path",
")",
".",
"lower",
"(",
")",
".",
"startswith",
"(",
"cfg",
".",
"download_dir",
".",
"get_path",
"(",
")",
... | remove files of each path in the list . | train | false |
70 | def get_discount_modules():
return load_module_instances('SHUUP_DISCOUNT_MODULES', 'discount_module')
| [
"def",
"get_discount_modules",
"(",
")",
":",
"return",
"load_module_instances",
"(",
"'SHUUP_DISCOUNT_MODULES'",
",",
"'discount_module'",
")"
] | get a list of configured discount module instances . | train | false |
73 | def initialize_log_data(ids_bcs_added_field):
log_data = {}
for curr_key in ids_bcs_added_field.keys():
base_key = ''
if curr_key[0]:
base_key += (curr_key[0] + ',')
if curr_key[1]:
base_key += (curr_key[1] + ',')
base_key += ids_bcs_added_field[curr_key]
log_data[base_key] = 0
return log_data
| [
"def",
"initialize_log_data",
"(",
"ids_bcs_added_field",
")",
":",
"log_data",
"=",
"{",
"}",
"for",
"curr_key",
"in",
"ids_bcs_added_field",
".",
"keys",
"(",
")",
":",
"base_key",
"=",
"''",
"if",
"curr_key",
"[",
"0",
"]",
":",
"base_key",
"+=",
"(",
... | initializes log data . | train | false |
76 | def is_sequence_of_strings(obj):
if (not cbook.iterable(obj)):
return False
if ((not isinstance(obj, np.ndarray)) and cbook.is_string_like(obj)):
return False
for o in obj:
if (not cbook.is_string_like(o)):
return False
return True
| [
"def",
"is_sequence_of_strings",
"(",
"obj",
")",
":",
"if",
"(",
"not",
"cbook",
".",
"iterable",
"(",
"obj",
")",
")",
":",
"return",
"False",
"if",
"(",
"(",
"not",
"isinstance",
"(",
"obj",
",",
"np",
".",
"ndarray",
")",
")",
"and",
"cbook",
"... | returns true if *obj* is iterable and contains strings . | train | false |
77 | def highlighting(view, name, style, left, right):
if (left is not None):
left = left.move((left.begin + BEGIN_LEN), (left.end - BRACKET_LEN))
if (right is not None):
right = right.move((right.begin + END_LEN), (right.end - BRACKET_LEN))
return (left, right)
| [
"def",
"highlighting",
"(",
"view",
",",
"name",
",",
"style",
",",
"left",
",",
"right",
")",
":",
"if",
"(",
"left",
"is",
"not",
"None",
")",
":",
"left",
"=",
"left",
".",
"move",
"(",
"(",
"left",
".",
"begin",
"+",
"BEGIN_LEN",
")",
",",
... | highlight only the tag name . | train | false |
78 | def _inFilesystemNamespace(path):
return (path[:1] not in ('\x00', u'\x00'))
| [
"def",
"_inFilesystemNamespace",
"(",
"path",
")",
":",
"return",
"(",
"path",
"[",
":",
"1",
"]",
"not",
"in",
"(",
"'\\x00'",
",",
"u'\\x00'",
")",
")"
] | determine whether the given unix socket path is in a filesystem namespace . | train | false |
79 | def set_policy(name, table='filter', family='ipv4', **kwargs):
ret = {'name': name, 'changes': {}, 'result': None, 'comment': ''}
for ignore in _STATE_INTERNAL_KEYWORDS:
if (ignore in kwargs):
del kwargs[ignore]
if (__salt__['iptables.get_policy'](table, kwargs['chain'], family) == kwargs['policy']):
ret['result'] = True
ret['comment'] = 'iptables default policy for chain {0} on table {1} for {2} already set to {3}'.format(kwargs['chain'], table, family, kwargs['policy'])
return ret
if __opts__['test']:
ret['comment'] = 'iptables default policy for chain {0} on table {1} for {2} needs to be set to {3}'.format(kwargs['chain'], table, family, kwargs['policy'])
return ret
if (not __salt__['iptables.set_policy'](table, kwargs['chain'], kwargs['policy'], family)):
ret['changes'] = {'locale': name}
ret['result'] = True
ret['comment'] = 'Set default policy for {0} to {1} family {2}'.format(kwargs['chain'], kwargs['policy'], family)
if ('save' in kwargs):
if kwargs['save']:
__salt__['iptables.save'](filename=None, family=family)
ret['comment'] = 'Set and saved default policy for {0} to {1} family {2}'.format(kwargs['chain'], kwargs['policy'], family)
return ret
else:
ret['result'] = False
ret['comment'] = 'Failed to set iptables default policy'
return ret
| [
"def",
"set_policy",
"(",
"name",
",",
"table",
"=",
"'filter'",
",",
"family",
"=",
"'ipv4'",
",",
"**",
"kwargs",
")",
":",
"ret",
"=",
"{",
"'name'",
":",
"name",
",",
"'changes'",
":",
"{",
"}",
",",
"'result'",
":",
"None",
",",
"'comment'",
"... | set the current policy for the specified table/chain cli example: . | train | true |
80 | def test_formatters(Chart):
if (Chart._dual or (Chart == Box)):
return
chart = Chart(formatter=(lambda x, chart, serie: ('%s%s$' % (x, serie.title))))
chart.add('_a', [1, 2, {'value': 3, 'formatter': (lambda x: (u('%s\xc2\xa5') % x))}])
chart.add('_b', [4, 5, 6], formatter=(lambda x: (u('%s\xe2\x82\xac') % x)))
chart.x_labels = [2, 4, 6]
chart.x_labels_major = [4]
q = chart.render_pyquery()
assert (set([v.text for v in q('.value')]) == set(((u('4\xe2\x82\xac'), u('5\xe2\x82\xac'), u('6\xe2\x82\xac'), '1_a$', '2_a$', u('3\xc2\xa5')) + (('6_a$', u('15\xe2\x82\xac')) if (Chart in (Pie, SolidGauge)) else ()))))
| [
"def",
"test_formatters",
"(",
"Chart",
")",
":",
"if",
"(",
"Chart",
".",
"_dual",
"or",
"(",
"Chart",
"==",
"Box",
")",
")",
":",
"return",
"chart",
"=",
"Chart",
"(",
"formatter",
"=",
"(",
"lambda",
"x",
",",
"chart",
",",
"serie",
":",
"(",
... | test custom formatters . | train | false |
81 | def test_sort():
model = _create_model([[('B', '', '', 1), ('C', '', '', 2), ('A', '', '', 0)]])
filter_model = sortfilter.CompletionFilterModel(model)
filter_model.sort(0, Qt.AscendingOrder)
actual = _extract_model_data(filter_model)
assert (actual == [[('A', '', ''), ('B', '', ''), ('C', '', '')]])
filter_model.sort(0, Qt.DescendingOrder)
actual = _extract_model_data(filter_model)
assert (actual == [[('C', '', ''), ('B', '', ''), ('A', '', '')]])
| [
"def",
"test_sort",
"(",
")",
":",
"model",
"=",
"_create_model",
"(",
"[",
"[",
"(",
"'B'",
",",
"''",
",",
"''",
",",
"1",
")",
",",
"(",
"'C'",
",",
"''",
",",
"''",
",",
"2",
")",
",",
"(",
"'A'",
",",
"''",
",",
"''",
",",
"0",
")",
... | ensure that a sort argument passed to sort overrides dumb_sort . | train | false |
82 | def create_dendrogram(X, orientation='bottom', labels=None, colorscale=None, distfun=None, linkagefun=(lambda x: sch.linkage(x, 'complete'))):
if ((not scp) or (not scs) or (not sch)):
raise ImportError('FigureFactory.create_dendrogram requires scipy, scipy.spatial and scipy.hierarchy')
s = X.shape
if (len(s) != 2):
exceptions.PlotlyError('X should be 2-dimensional array.')
if (distfun is None):
distfun = scs.distance.pdist
dendrogram = _Dendrogram(X, orientation, labels, colorscale, distfun=distfun, linkagefun=linkagefun)
return {'layout': dendrogram.layout, 'data': dendrogram.data}
| [
"def",
"create_dendrogram",
"(",
"X",
",",
"orientation",
"=",
"'bottom'",
",",
"labels",
"=",
"None",
",",
"colorscale",
"=",
"None",
",",
"distfun",
"=",
"None",
",",
"linkagefun",
"=",
"(",
"lambda",
"x",
":",
"sch",
".",
"linkage",
"(",
"x",
",",
... | beta function that returns a dendrogram plotly figure object . | train | false |
83 | def uni_print(statement, out_file=None):
if (out_file is None):
out_file = sys.stdout
try:
out_file.write(statement)
except UnicodeEncodeError:
new_encoding = getattr(out_file, 'encoding', 'ascii')
if (new_encoding is None):
new_encoding = 'ascii'
new_statement = statement.encode(new_encoding, 'replace').decode(new_encoding)
out_file.write(new_statement)
out_file.flush()
| [
"def",
"uni_print",
"(",
"statement",
",",
"out_file",
"=",
"None",
")",
":",
"if",
"(",
"out_file",
"is",
"None",
")",
":",
"out_file",
"=",
"sys",
".",
"stdout",
"try",
":",
"out_file",
".",
"write",
"(",
"statement",
")",
"except",
"UnicodeEncodeError... | this function is used to properly write unicode to a file . | train | false |
84 | def pretty_name(name):
if (not name):
return ''
return name.replace('_', ' ').capitalize()
| [
"def",
"pretty_name",
"(",
"name",
")",
":",
"if",
"(",
"not",
"name",
")",
":",
"return",
"''",
"return",
"name",
".",
"replace",
"(",
"'_'",
",",
"' '",
")",
".",
"capitalize",
"(",
")"
] | converts first_name to first name . | train | false |
85 | def list_snapshots(config='root'):
try:
snapshots = snapper.ListSnapshots(config)
return [_snapshot_to_data(s) for s in snapshots]
except dbus.DBusException as exc:
raise CommandExecutionError('Error encountered while listing snapshots: {0}'.format(_dbus_exception_to_reason(exc, locals())))
| [
"def",
"list_snapshots",
"(",
"config",
"=",
"'root'",
")",
":",
"try",
":",
"snapshots",
"=",
"snapper",
".",
"ListSnapshots",
"(",
"config",
")",
"return",
"[",
"_snapshot_to_data",
"(",
"s",
")",
"for",
"s",
"in",
"snapshots",
"]",
"except",
"dbus",
"... | list available snapshots for certain vm or for all . | train | true |
86 | def branch_list(repo):
with open_repo_closing(repo) as r:
return r.refs.keys(base='refs/heads/')
| [
"def",
"branch_list",
"(",
"repo",
")",
":",
"with",
"open_repo_closing",
"(",
"repo",
")",
"as",
"r",
":",
"return",
"r",
".",
"refs",
".",
"keys",
"(",
"base",
"=",
"'refs/heads/'",
")"
] | return a list of local or remote branches this explicitly removes head from the list of remote branches . | train | false |
87 | @depends(HAS_PYVMOMI)
def get_ntp_config(host, username, password, protocol=None, port=None, host_names=None):
service_instance = salt.utils.vmware.get_service_instance(host=host, username=username, password=password, protocol=protocol, port=port)
host_names = _check_hosts(service_instance, host, host_names)
ret = {}
for host_name in host_names:
host_ref = _get_host_ref(service_instance, host, host_name=host_name)
ntp_config = host_ref.configManager.dateTimeSystem.dateTimeInfo.ntpConfig.server
ret.update({host_name: ntp_config})
return ret
| [
"@",
"depends",
"(",
"HAS_PYVMOMI",
")",
"def",
"get_ntp_config",
"(",
"host",
",",
"username",
",",
"password",
",",
"protocol",
"=",
"None",
",",
"port",
"=",
"None",
",",
"host_names",
"=",
"None",
")",
":",
"service_instance",
"=",
"salt",
".",
"util... | get the ntp configuration information for a given host or list of host_names . | train | true |
89 | def floating_ip_list(call=None):
if (call != 'function'):
raise SaltCloudSystemExit('The floating_ip_list action must be called with -f or --function')
conn = get_conn()
return conn.floating_ip_list()
| [
"def",
"floating_ip_list",
"(",
"call",
"=",
"None",
")",
":",
"if",
"(",
"call",
"!=",
"'function'",
")",
":",
"raise",
"SaltCloudSystemExit",
"(",
"'The floating_ip_list action must be called with -f or --function'",
")",
"conn",
"=",
"get_conn",
"(",
")",
"return... | list floating ips . | train | false |
90 | def tsql_query(query, **kwargs):
try:
cur = _get_connection(**kwargs).cursor()
cur.execute(query)
return loads(_MssqlEncoder().encode({'resultset': cur.fetchall()}))['resultset']
except Exception as e:
return (('Could not run the query',), (str(e),))
| [
"def",
"tsql_query",
"(",
"query",
",",
"**",
"kwargs",
")",
":",
"try",
":",
"cur",
"=",
"_get_connection",
"(",
"**",
"kwargs",
")",
".",
"cursor",
"(",
")",
"cur",
".",
"execute",
"(",
"query",
")",
"return",
"loads",
"(",
"_MssqlEncoder",
"(",
")... | run a sql query and return query result as list of tuples . | train | false |
92 | def per_cpu_times():
ret = cext.per_cpu_times()
return [scputimes(*x) for x in ret]
| [
"def",
"per_cpu_times",
"(",
")",
":",
"ret",
"=",
"cext",
".",
"per_cpu_times",
"(",
")",
"return",
"[",
"scputimes",
"(",
"*",
"x",
")",
"for",
"x",
"in",
"ret",
"]"
] | return system per-cpu times as a list of named tuples . | train | false |
93 | def _run_aws(cmd, region, opts, user, **kwargs):
receipthandle = kwargs.pop('receipthandle', None)
if receipthandle:
kwargs['receipt-handle'] = receipthandle
num = kwargs.pop('num', None)
if num:
kwargs['max-number-of-messages'] = num
_formatted_args = ['--{0} "{1}"'.format(k, v) for (k, v) in six.iteritems(kwargs)]
cmd = 'aws sqs {cmd} {args} {region} {out}'.format(cmd=cmd, args=' '.join(_formatted_args), region=_region(region), out=_OUTPUT)
rtn = __salt__['cmd.run'](cmd, runas=user, python_shell=False)
return (json.loads(rtn) if rtn else '')
| [
"def",
"_run_aws",
"(",
"cmd",
",",
"region",
",",
"opts",
",",
"user",
",",
"**",
"kwargs",
")",
":",
"receipthandle",
"=",
"kwargs",
".",
"pop",
"(",
"'receipthandle'",
",",
"None",
")",
"if",
"receipthandle",
":",
"kwargs",
"[",
"'receipt-handle'",
"]... | runs the given command against aws . | train | true |
94 | def TrimmedMean(t, p=0.01):
t = Trim(t, p)
return Mean(t)
| [
"def",
"TrimmedMean",
"(",
"t",
",",
"p",
"=",
"0.01",
")",
":",
"t",
"=",
"Trim",
"(",
"t",
",",
"p",
")",
"return",
"Mean",
"(",
"t",
")"
] | computes the trimmed mean of a sequence of numbers . | train | false |
95 | def ePut(Handle, IOType, Channel, Value, x1):
if (os.name == 'nt'):
staticLib = ctypes.windll.LoadLibrary('labjackud')
pv = ctypes.c_double(Value)
ec = staticLib.ePut(Handle, IOType, Channel, pv, x1)
if (ec != 0):
raise LabJackException(ec)
else:
raise LabJackException(0, 'Function only supported for Windows')
| [
"def",
"ePut",
"(",
"Handle",
",",
"IOType",
",",
"Channel",
",",
"Value",
",",
"x1",
")",
":",
"if",
"(",
"os",
".",
"name",
"==",
"'nt'",
")",
":",
"staticLib",
"=",
"ctypes",
".",
"windll",
".",
"LoadLibrary",
"(",
"'labjackud'",
")",
"pv",
"=",... | put one value to the labjack device eput is equivilent to an addrequest followed by a goone . | train | false |
97 | def local_binary_pattern(image, P, R, method='default'):
assert_nD(image, 2)
methods = {'default': ord('D'), 'ror': ord('R'), 'uniform': ord('U'), 'nri_uniform': ord('N'), 'var': ord('V')}
image = np.ascontiguousarray(image, dtype=np.double)
output = _local_binary_pattern(image, P, R, methods[method.lower()])
return output
| [
"def",
"local_binary_pattern",
"(",
"image",
",",
"P",
",",
"R",
",",
"method",
"=",
"'default'",
")",
":",
"assert_nD",
"(",
"image",
",",
"2",
")",
"methods",
"=",
"{",
"'default'",
":",
"ord",
"(",
"'D'",
")",
",",
"'ror'",
":",
"ord",
"(",
"'R'... | gray scale and rotation invariant lbp . | train | false |
98 | def handleNewest(qry):
try:
getUserName()
except:
return _skypeError()
qry = qry.decode('utf8')
try:
if ((':' in qry) and (qry.partition(':')[0] in map((lambda s: s[0]), _readFriends()))):
return _sendMessageWait(qry)
else:
return _findNewest()
except EnvironmentError:
return PyFred('ch.xtin.skypingalfred.error', False).addItem('skypeupdate', 'skype update', 'No Skype Friends Found', 'Use skype update to cache friends!', True, 'update').toXML()
except:
return PyFred.GenericError()
| [
"def",
"handleNewest",
"(",
"qry",
")",
":",
"try",
":",
"getUserName",
"(",
")",
"except",
":",
"return",
"_skypeError",
"(",
")",
"qry",
"=",
"qry",
".",
"decode",
"(",
"'utf8'",
")",
"try",
":",
"if",
"(",
"(",
"':'",
"in",
"qry",
")",
"and",
... | gets the newest 5 messages . | train | false |
99 | @validate('tree')
def valid_field_in_tree(arch):
return all(((child.tag in ('field', 'button')) for child in arch.xpath('/tree/*')))
| [
"@",
"validate",
"(",
"'tree'",
")",
"def",
"valid_field_in_tree",
"(",
"arch",
")",
":",
"return",
"all",
"(",
"(",
"(",
"child",
".",
"tag",
"in",
"(",
"'field'",
",",
"'button'",
")",
")",
"for",
"child",
"in",
"arch",
".",
"xpath",
"(",
"'/tree/*... | children of tree view must be field or button . | train | false |
100 | def cr_uid_ids(method):
method._api = 'cr_uid_ids'
return method
| [
"def",
"cr_uid_ids",
"(",
"method",
")",
":",
"method",
".",
"_api",
"=",
"'cr_uid_ids'",
"return",
"method"
] | decorate a traditional-style method that takes cr . | train | false |
101 | def issue_section(issue):
labels = issue.get('labels', [])
for label in labels:
if (not label['name'].startswith('type: ')):
continue
if (label['name'] in LOG_SECTION):
return LOG_SECTION[label['name']]
elif (label['name'] in IGNORE_ISSUE_TYPE):
return None
else:
logging.warn('unknown issue type: "{}" for: {}'.format(label['name'], issue_line(issue)))
return None
| [
"def",
"issue_section",
"(",
"issue",
")",
":",
"labels",
"=",
"issue",
".",
"get",
"(",
"'labels'",
",",
"[",
"]",
")",
"for",
"label",
"in",
"labels",
":",
"if",
"(",
"not",
"label",
"[",
"'name'",
"]",
".",
"startswith",
"(",
"'type: '",
")",
")... | returns the section heading for the issue . | train | true |
103 | @transaction.non_atomic_requests
@ensure_csrf_cookie
@cache_control(no_cache=True, no_store=True, must_revalidate=True)
@require_global_staff
@require_http_methods(['POST', 'DELETE'])
def certificate_invalidation_view(request, course_id):
course_key = CourseKey.from_string(course_id)
try:
certificate_invalidation_data = parse_request_data(request)
certificate = validate_request_data_and_get_certificate(certificate_invalidation_data, course_key)
except ValueError as error:
return JsonResponse({'message': error.message}, status=400)
if (request.method == 'POST'):
try:
certificate_invalidation = invalidate_certificate(request, certificate, certificate_invalidation_data)
except ValueError as error:
return JsonResponse({'message': error.message}, status=400)
return JsonResponse(certificate_invalidation)
elif (request.method == 'DELETE'):
try:
re_validate_certificate(request, course_key, certificate)
except ValueError as error:
return JsonResponse({'message': error.message}, status=400)
return JsonResponse({}, status=204)
| [
"@",
"transaction",
".",
"non_atomic_requests",
"@",
"ensure_csrf_cookie",
"@",
"cache_control",
"(",
"no_cache",
"=",
"True",
",",
"no_store",
"=",
"True",
",",
"must_revalidate",
"=",
"True",
")",
"@",
"require_global_staff",
"@",
"require_http_methods",
"(",
"[... | invalidate/re-validate students to/from certificate . | train | false |
104 | def rollback():
connection._rollback()
set_clean()
| [
"def",
"rollback",
"(",
")",
":",
"connection",
".",
"_rollback",
"(",
")",
"set_clean",
"(",
")"
] | rolls back a transaction . | train | false |
105 | def _mathdefault(s):
if rcParams[u'_internal.classic_mode']:
return (u'\\mathdefault{%s}' % s)
else:
return (u'{%s}' % s)
| [
"def",
"_mathdefault",
"(",
"s",
")",
":",
"if",
"rcParams",
"[",
"u'_internal.classic_mode'",
"]",
":",
"return",
"(",
"u'\\\\mathdefault{%s}'",
"%",
"s",
")",
"else",
":",
"return",
"(",
"u'{%s}'",
"%",
"s",
")"
] | for backward compatibility . | train | false |
106 | @requires_sklearn
def test_gat_plot_nonsquared():
gat = _get_data(test_times=dict(start=0.0))
gat.plot()
ax = gat.plot_diagonal()
scores = ax.get_children()[1].get_lines()[2].get_ydata()
assert_equals(len(scores), len(gat.estimators_))
| [
"@",
"requires_sklearn",
"def",
"test_gat_plot_nonsquared",
"(",
")",
":",
"gat",
"=",
"_get_data",
"(",
"test_times",
"=",
"dict",
"(",
"start",
"=",
"0.0",
")",
")",
"gat",
".",
"plot",
"(",
")",
"ax",
"=",
"gat",
".",
"plot_diagonal",
"(",
")",
"sco... | test gat diagonal plot . | train | false |
107 | def _add_keys_to_request(request_field_pb, key_pbs):
for key_pb in key_pbs:
request_field_pb.add().CopyFrom(key_pb)
| [
"def",
"_add_keys_to_request",
"(",
"request_field_pb",
",",
"key_pbs",
")",
":",
"for",
"key_pb",
"in",
"key_pbs",
":",
"request_field_pb",
".",
"add",
"(",
")",
".",
"CopyFrom",
"(",
"key_pb",
")"
] | add protobuf keys to a request object . | train | false |
108 | def execute_on_completion(application, config, callback):
def inner(environ, start_response):
try:
result = application(environ, start_response)
except:
callback(environ)
raise
return generate_close_and_callback(result, callback, environ)
return inner
| [
"def",
"execute_on_completion",
"(",
"application",
",",
"config",
",",
"callback",
")",
":",
"def",
"inner",
"(",
"environ",
",",
"start_response",
")",
":",
"try",
":",
"result",
"=",
"application",
"(",
"environ",
",",
"start_response",
")",
"except",
":"... | call callback once complete response is sent . | train | false |
109 | def qt5_qml_data(directory):
qmldir = qt5_qml_dir()
return (os.path.join(qmldir, directory), 'qml')
| [
"def",
"qt5_qml_data",
"(",
"directory",
")",
":",
"qmldir",
"=",
"qt5_qml_dir",
"(",
")",
"return",
"(",
"os",
".",
"path",
".",
"join",
"(",
"qmldir",
",",
"directory",
")",
",",
"'qml'",
")"
] | return qml library directory formatted for data . | train | false |
110 | def require_finance_admin(func):
def wrapped(request, course_id):
try:
course_key = CourseKey.from_string(course_id)
except InvalidKeyError:
log.error(u'Unable to find course with course key %s', course_id)
return HttpResponseNotFound()
access = auth.user_has_role(request.user, CourseFinanceAdminRole(course_key))
if access:
return func(request, course_id)
else:
return HttpResponseForbidden()
return wrapped
| [
"def",
"require_finance_admin",
"(",
"func",
")",
":",
"def",
"wrapped",
"(",
"request",
",",
"course_id",
")",
":",
"try",
":",
"course_key",
"=",
"CourseKey",
".",
"from_string",
"(",
"course_id",
")",
"except",
"InvalidKeyError",
":",
"log",
".",
"error",... | decorator for checking finance administrator access before executing an http endpoint . | train | false |
111 | def addBeginXMLTag(attributeDictionary, className, depth, output, text=''):
depthStart = (' DCTB ' * depth)
output.write(('%s<%s%s>%s\n' % (depthStart, className, getAttributeDictionaryString(attributeDictionary), text)))
| [
"def",
"addBeginXMLTag",
"(",
"attributeDictionary",
",",
"className",
",",
"depth",
",",
"output",
",",
"text",
"=",
"''",
")",
":",
"depthStart",
"=",
"(",
"' DCTB '",
"*",
"depth",
")",
"output",
".",
"write",
"(",
"(",
"'%s<%s%s>%s\\n'",
"%",
"(",
"d... | add the begin xml tag . | train | false |
113 | def test_cons_list():
entry = tokenize('(a . [])')[0]
assert (entry == HyList([HySymbol('a')]))
assert (type(entry) == HyList)
entry = tokenize('(a . ())')[0]
assert (entry == HyExpression([HySymbol('a')]))
assert (type(entry) == HyExpression)
entry = tokenize('(a b . {})')[0]
assert (entry == HyDict([HySymbol('a'), HySymbol('b')]))
assert (type(entry) == HyDict)
| [
"def",
"test_cons_list",
"(",
")",
":",
"entry",
"=",
"tokenize",
"(",
"'(a . [])'",
")",
"[",
"0",
"]",
"assert",
"(",
"entry",
"==",
"HyList",
"(",
"[",
"HySymbol",
"(",
"'a'",
")",
"]",
")",
")",
"assert",
"(",
"type",
"(",
"entry",
")",
"==",
... | check that cons of something and a list gets tokenized as a list . | train | false |
114 | def _wait_for_step(emr_connection, step, jobflowid, sleeptime):
sleep(180)
start = time()
step_state = get_step_state(emr_connection, jobflowid, step.name, update=True)
while (step_state in (LIVE_STATES + [PENDING])):
sleep(sleeptime)
step_state = get_step_state(emr_connection, jobflowid, step.name)
end = time()
print ('%s took %0.2fs (exit: %s)' % (step.name, (end - start), step_state))
return step_state
| [
"def",
"_wait_for_step",
"(",
"emr_connection",
",",
"step",
",",
"jobflowid",
",",
"sleeptime",
")",
":",
"sleep",
"(",
"180",
")",
"start",
"=",
"time",
"(",
")",
"step_state",
"=",
"get_step_state",
"(",
"emr_connection",
",",
"jobflowid",
",",
"step",
... | poll emr and wait for a step to finish . | train | false |
116 | def get_occupied_streams(realm):
subs_filter = Subscription.objects.filter(active=True, user_profile__realm=realm, user_profile__is_active=True).values('recipient_id')
stream_ids = Recipient.objects.filter(type=Recipient.STREAM, id__in=subs_filter).values('type_id')
return Stream.objects.filter(id__in=stream_ids, realm=realm, deactivated=False)
| [
"def",
"get_occupied_streams",
"(",
"realm",
")",
":",
"subs_filter",
"=",
"Subscription",
".",
"objects",
".",
"filter",
"(",
"active",
"=",
"True",
",",
"user_profile__realm",
"=",
"realm",
",",
"user_profile__is_active",
"=",
"True",
")",
".",
"values",
"("... | get streams with subscribers . | train | false |
117 | def test_find_number_6():
s = 'query1e5 not found'
r = find_number(s)
assert (s[r[0]:r[1]] == '1e5')
| [
"def",
"test_find_number_6",
"(",
")",
":",
"s",
"=",
"'query1e5 not found'",
"r",
"=",
"find_number",
"(",
"s",
")",
"assert",
"(",
"s",
"[",
"r",
"[",
"0",
"]",
":",
"r",
"[",
"1",
"]",
"]",
"==",
"'1e5'",
")"
] | tests that we find numbers with exponents . | train | false |
118 | def _build_match_rule(action, target, pluralized):
match_rule = policy.RuleCheck('rule', action)
(resource, enforce_attr_based_check) = get_resource_and_action(action, pluralized)
if enforce_attr_based_check:
res_map = attributes.RESOURCE_ATTRIBUTE_MAP
if (resource in res_map):
for attribute_name in res_map[resource]:
if _is_attribute_explicitly_set(attribute_name, res_map[resource], target, action):
attribute = res_map[resource][attribute_name]
if ('enforce_policy' in attribute):
attr_rule = policy.RuleCheck('rule', ('%s:%s' % (action, attribute_name)))
if _should_validate_sub_attributes(attribute, target[attribute_name]):
attr_rule = policy.AndCheck([attr_rule, _build_subattr_match_rule(attribute_name, attribute, action, target)])
match_rule = policy.AndCheck([match_rule, attr_rule])
return match_rule
| [
"def",
"_build_match_rule",
"(",
"action",
",",
"target",
",",
"pluralized",
")",
":",
"match_rule",
"=",
"policy",
".",
"RuleCheck",
"(",
"'rule'",
",",
"action",
")",
"(",
"resource",
",",
"enforce_attr_based_check",
")",
"=",
"get_resource_and_action",
"(",
... | create the rule to match for a given action . | train | false |
119 | def dmp_ground_LC(f, u, K):
while u:
f = dmp_LC(f, K)
u -= 1
return dup_LC(f, K)
| [
"def",
"dmp_ground_LC",
"(",
"f",
",",
"u",
",",
"K",
")",
":",
"while",
"u",
":",
"f",
"=",
"dmp_LC",
"(",
"f",
",",
"K",
")",
"u",
"-=",
"1",
"return",
"dup_LC",
"(",
"f",
",",
"K",
")"
] | return the ground leading coefficient . | train | false |
120 | def getNewRepository():
return ExportRepository()
| [
"def",
"getNewRepository",
"(",
")",
":",
"return",
"ExportRepository",
"(",
")"
] | get new repository . | train | false |
122 | def get_entrance_exam_score(request, course):
exam_key = UsageKey.from_string(course.entrance_exam_id)
exam_descriptor = modulestore().get_item(exam_key)
def inner_get_module(descriptor):
'\n Delegate to get_module_for_descriptor (imported here to avoid circular reference)\n '
from courseware.module_render import get_module_for_descriptor
field_data_cache = FieldDataCache([descriptor], course.id, request.user)
return get_module_for_descriptor(request.user, request, descriptor, field_data_cache, course.id, course=course)
exam_module_generators = yield_dynamic_descriptor_descendants(exam_descriptor, request.user.id, inner_get_module)
exam_modules = [module for module in exam_module_generators]
return _calculate_entrance_exam_score(request.user, course, exam_modules)
| [
"def",
"get_entrance_exam_score",
"(",
"request",
",",
"course",
")",
":",
"exam_key",
"=",
"UsageKey",
".",
"from_string",
"(",
"course",
".",
"entrance_exam_id",
")",
"exam_descriptor",
"=",
"modulestore",
"(",
")",
".",
"get_item",
"(",
"exam_key",
")",
"de... | gather the set of modules which comprise the entrance exam note that request may not actually be a genuine request . | train | false |
124 | def load_passphrase_from_file():
vf_path = os.path.expanduser(kVFPassphraseFile)
assert (os.access(vf_path, os.F_OK) and os.access(vf_path, os.R_OK)), ('%s must exist and be readable' % vf_path)
with open(vf_path) as f:
user_data = f.read()
return user_data.strip('\n')
| [
"def",
"load_passphrase_from_file",
"(",
")",
":",
"vf_path",
"=",
"os",
".",
"path",
".",
"expanduser",
"(",
"kVFPassphraseFile",
")",
"assert",
"(",
"os",
".",
"access",
"(",
"vf_path",
",",
"os",
".",
"F_OK",
")",
"and",
"os",
".",
"access",
"(",
"v... | read the viewfinder passphrase from local file . | train | false |
125 | def describe_identity_pools(IdentityPoolName, IdentityPoolId=None, region=None, key=None, keyid=None, profile=None):
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
try:
ids = _find_identity_pool_ids(IdentityPoolName, IdentityPoolId, conn)
if ids:
results = []
for pool_id in ids:
response = conn.describe_identity_pool(IdentityPoolId=pool_id)
response.pop('ResponseMetadata', None)
results.append(response)
return {'identity_pools': results}
else:
return {'identity_pools': None}
except ClientError as e:
return {'error': salt.utils.boto3.get_error(e)}
| [
"def",
"describe_identity_pools",
"(",
"IdentityPoolName",
",",
"IdentityPoolId",
"=",
"None",
",",
"region",
"=",
"None",
",",
"key",
"=",
"None",
",",
"keyid",
"=",
"None",
",",
"profile",
"=",
"None",
")",
":",
"conn",
"=",
"_get_conn",
"(",
"region",
... | given an identity pool name . | train | false |
126 | @register.simple_tag(takes_context=True)
def zinnia_loop_template(context, default_template):
(matching, context_object) = get_context_first_matching_object(context, ['category', 'tag', 'author', 'pattern', 'year', 'month', 'week', 'day'])
context_positions = get_context_loop_positions(context)
templates = loop_template_list(context_positions, context_object, matching, default_template, ENTRY_LOOP_TEMPLATES)
return select_template(templates)
| [
"@",
"register",
".",
"simple_tag",
"(",
"takes_context",
"=",
"True",
")",
"def",
"zinnia_loop_template",
"(",
"context",
",",
"default_template",
")",
":",
"(",
"matching",
",",
"context_object",
")",
"=",
"get_context_first_matching_object",
"(",
"context",
","... | return a selected template from his position within a loop and the filtering context . | train | false |
127 | def loadExperimentDescriptionScriptFromDir(experimentDir):
descriptionScriptPath = os.path.join(experimentDir, 'description.py')
module = _loadDescriptionFile(descriptionScriptPath)
return module
| [
"def",
"loadExperimentDescriptionScriptFromDir",
"(",
"experimentDir",
")",
":",
"descriptionScriptPath",
"=",
"os",
".",
"path",
".",
"join",
"(",
"experimentDir",
",",
"'description.py'",
")",
"module",
"=",
"_loadDescriptionFile",
"(",
"descriptionScriptPath",
")",
... | loads the experiment description python script from the given experiment directory . | train | true |
128 | def token_list_to_text(tokenlist):
ZeroWidthEscape = Token.ZeroWidthEscape
return u''.join((item[1] for item in tokenlist if (item[0] != ZeroWidthEscape)))
| [
"def",
"token_list_to_text",
"(",
"tokenlist",
")",
":",
"ZeroWidthEscape",
"=",
"Token",
".",
"ZeroWidthEscape",
"return",
"u''",
".",
"join",
"(",
"(",
"item",
"[",
"1",
"]",
"for",
"item",
"in",
"tokenlist",
"if",
"(",
"item",
"[",
"0",
"]",
"!=",
"... | concatenate all the text parts again . | train | true |
129 | @profiler.trace
def transfer_list(request, detailed=True, search_opts=None):
c_client = cinderclient(request)
try:
return [VolumeTransfer(v) for v in c_client.transfers.list(detailed=detailed, search_opts=search_opts)]
except cinder_exception.Forbidden as error:
LOG.error(error)
return []
| [
"@",
"profiler",
".",
"trace",
"def",
"transfer_list",
"(",
"request",
",",
"detailed",
"=",
"True",
",",
"search_opts",
"=",
"None",
")",
":",
"c_client",
"=",
"cinderclient",
"(",
"request",
")",
"try",
":",
"return",
"[",
"VolumeTransfer",
"(",
"v",
"... | to see all volumes transfers as an admin pass in a special search option: {all_tenants: 1} . | train | true |
131 | def test_discretize_callable_1d():
def f(x):
return (x ** 2)
y = discretize_model(f, ((-5), 6))
assert_allclose(y, (np.arange((-5), 6) ** 2))
| [
"def",
"test_discretize_callable_1d",
"(",
")",
":",
"def",
"f",
"(",
"x",
")",
":",
"return",
"(",
"x",
"**",
"2",
")",
"y",
"=",
"discretize_model",
"(",
"f",
",",
"(",
"(",
"-",
"5",
")",
",",
"6",
")",
")",
"assert_allclose",
"(",
"y",
",",
... | test discretize when a 1d function is passed . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.